Maskinlæringspipeline: Utvikling av egendefinerte transformatorer i Scikit-learn

Maskinlæringspipelines er essensielle for å bygge robuste og vedlikeholdbare maskinlæringsmodeller. Scikit-learn (sklearn) tilbyr et kraftig rammeverk for å lage disse pipelinene. En nøkkelkomponent i enhver god pipeline er evnen til å utføre egendefinerte datatransformasjoner. Denne artikkelen utforsker utviklingen av egendefinerte transformatorer i scikit-learn, og gir en omfattende guide for dataforskere og maskinlæringsingeniører over hele verden.

Hva er en maskinlæringspipeline?

En maskinlæringspipeline er en sekvens av databehandlingskomponenter som er lenket sammen. Disse komponentene inkluderer vanligvis:

• Datarensing: Håndtering av manglende verdier, uteliggere og inkonsistenser.
• Funksjonsutvikling: Opprette nye funksjoner fra eksisterende for å forbedre modellytelsen.
• Funksjonsutvelgelse: Velge de mest relevante funksjonene for modellen.
• Modelltrening: Trene en maskinlæringsmodell på de forberedte dataene.
• Modellevaluering: Vurdere ytelsen til den trente modellen.

Bruk av en pipeline gir flere fordeler, inkludert:

• Reproduserbarhet: Sikre at de samme databehandlingstrinnene brukes konsekvent.
• Modularitet: Bryte ned databehandlingsflyten i gjenbrukbare komponenter.
• Vedlikeholdbarhet: Gjøre det enklere å oppdatere og vedlikeholde databehandlingsflyten.
• Forenklet distribusjon: Strømlinjeforme prosessen med å distribuere maskinlæringsmodeller.

Hvorfor egendefinerte transformatorer?

Scikit-learn tilbyr et bredt spekter av innebygde transformatorer for vanlige databehandlingsoppgaver. I mange virkelige scenarioer vil du imidlertid måtte utføre egendefinerte datatransformasjoner som er spesifikke for dine data og ditt problem. Det er her egendefinerte transformatorer kommer inn. Egendefinerte transformatorer lar deg kapsle inn din egendefinerte databehandlingslogikk i gjenbrukbare komponenter som kan integreres sømløst i en scikit-learn pipeline.

Forestill deg for eksempel at du jobber med kundedata fra en global e-handelsplattform. Du kan trenge å lage en egendefinert transformator som konverterer transaksjonsvalutaer til en felles valuta (f.eks. USD) basert på historiske valutakurser. Eller, vurder et scenario som involverer sensordata fra IoT-enheter i forskjellige land; du kan bygge en egendefinert transformator for å normalisere data basert på lokale tidssoner og måleenheter.

Hvordan bygge en egendefinert transformator

For å lage en egendefinert transformator i scikit-learn, må du opprette en klasse som arver fra sklearn.base.BaseEstimator og sklearn.base.TransformerMixin. Klassen din må implementere to metoder:

• fit(self, X, y=None): Denne metoden lærer eventuelle parametere som er nødvendige for transformasjonen. I mange tilfeller returnerer denne metoden bare self.
• transform(self, X): Denne metoden anvender transformasjonen på dataene.

Her er et grunnleggende eksempel på en egendefinert transformator som legger til en konstant verdi til hver funksjon:

            from sklearn.base import BaseEstimator, TransformerMixin
import numpy as np

class AddConstantTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, constant=1):
        self.constant = constant

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        return X + self.constant

            

              
                Copy
              
            
          

La oss bryte ned dette eksempelet:

• Importer nødvendige biblioteker: BaseEstimator, TransformerMixin fra sklearn.base og numpy for numeriske operasjoner.
• Definer klassen: AddConstantTransformer arver fra BaseEstimator og TransformerMixin.
• Konstruktør (__init__): Denne metoden initialiserer transformatoren med en constant-verdi (standard er 1).
• fit-metoden: Denne metoden returnerer bare self, siden denne transformatoren ikke trenger å lære noen parametere fra dataene.
• transform-metoden: Denne metoden legger til constant-verdien til hvert element i inndataene X.

Eksempel på bruk

            from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

X = np.array([[1, 2], [3, 4], [5, 6]])

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('add_constant', AddConstantTransformer(constant=2))
])

X_transformed = pipeline.fit_transform(X)

print(X_transformed)

            

              
                Copy
              
            
          

Dette eksempelet demonstrerer hvordan du bruker AddConstantTransformer i en pipeline. Først skaleres dataene med StandardScaler, og deretter legges konstanten til ved hjelp av vår egendefinerte transformator.

Avansert utvikling av egendefinerte transformatorer

La oss nå utforske noen mer avanserte scenarioer og teknikker for å bygge egendefinerte transformatorer.

Håndtering av kategoriske funksjoner

Kategoriske funksjoner er en vanlig datatype i maskinlæring. Du kan lage egendefinerte transformatorer for å utføre ulike operasjoner på kategoriske funksjoner, som one-hot-koding, etiketkoding eller funksjons-hashing.

Her er et eksempel på en egendefinert transformator som utfører one-hot-koding på spesifiserte kolonner:

            import pandas as pd
from sklearn.preprocessing import OneHotEncoder

class CategoricalEncoder(BaseEstimator, TransformerMixin):
    def __init__(self, categorical_features=None):
        self.categorical_features = categorical_features
        self.encoder = None

    def fit(self, X, y=None):
        if self.categorical_features is None:
            self.categorical_features = X.select_dtypes(include=['object']).columns

        self.encoder = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
        self.encoder.fit(X[self.categorical_features])
        return self

    def transform(self, X):
        X_encoded = self.encoder.transform(X[self.categorical_features])
        X_encoded = pd.DataFrame(X_encoded, index=X.index, columns=self.encoder.get_feature_names_out(self.categorical_features))
        X = X.drop(columns=self.categorical_features)
        X = pd.concat([X, X_encoded], axis=1)
        return X

            

              
                Copy
              
            
          

I dette eksempelet:

• Transformatoren identifiserer kategoriske kolonner automatisk (hvis ikke spesifisert).
• Den bruker OneHotEncoder fra scikit-learn til å utføre kodingen.
• Den håndterer ukjente kategorier ved hjelp av handle_unknown='ignore'.
• De kodede funksjonene blir slått sammen med den opprinnelige dataframe-en.

Håndtering av manglende verdier

Manglende verdier er et annet vanlig problem i maskinlæringsdatasett. Du kan lage egendefinerte transformatorer for å imputere manglende verdier ved hjelp av ulike strategier, som gjennomsnittsimputering, medianimputering eller modusimputering.

Her er et eksempel på en egendefinert transformator som imputer manglende verdier ved hjelp av medianen:

            from sklearn.impute import SimpleImputer

class MissingValueImputer(BaseEstimator, TransformerMixin):
    def __init__(self, strategy='median', missing_values=np.nan):
        self.strategy = strategy
        self.missing_values = missing_values
        self.imputer = None

    def fit(self, X, y=None):
        self.imputer = SimpleImputer(strategy=self.strategy, missing_values=self.missing_values)
        self.imputer.fit(X)
        return self

    def transform(self, X):
        return self.imputer.transform(X)

            

              
                Copy
              
            
          

Denne transformatoren bruker SimpleImputer fra scikit-learn til å utføre imputeringen. Den lar deg spesifisere imputeringsstrategien og verdien som brukes for å representere manglende verdier.

Funksjonsskalering og normalisering

Funksjonsskalering og normalisering er viktige forbehandlingstrinn for mange maskinlæringsalgoritmer. Du kan lage egendefinerte transformatorer for å implementere forskjellige skalerings- og normaliseringsteknikker.

Selv om scikit-learn tilbyr transformatorer som StandardScaler og MinMaxScaler, kan du trenge en egendefinert skalerer for spesifikke datafordelinger. For eksempel, hvis du har data med en veldig skjev fordeling, kan en PowerTransformer (også tilgjengelig i scikit-learn) være mer passende. Du kan imidlertid kapsle den inn i en egendefinert transformator for å håndtere parameterne og integrere den sømløst i pipelinen din.

            from sklearn.preprocessing import PowerTransformer

class SkewedDataTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, method='yeo-johnson'):
        self.method = method
        self.transformer = None

    def fit(self, X, y=None):
        self.transformer = PowerTransformer(method=self.method)
        self.transformer.fit(X)
        return self

    def transform(self, X):
        return self.transformer.transform(X)

            

              
                Copy
              
            
          

Kombinere flere transformasjoner

Noen ganger kan det være nødvendig å anvende flere transformasjoner på de samme dataene. Du kan lage en egendefinert transformator som kombinerer flere transformasjoner i ett enkelt trinn. Dette kan bidra til å forenkle pipelinen din og gjøre den mer lesbar.

Her er et eksempel på en egendefinert transformator som kombinerer one-hot-koding og imputering av manglende verdier:

            class CombinedTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, categorical_features=None, missing_value_strategy='median'):
        self.categorical_features = categorical_features
        self.missing_value_strategy = missing_value_strategy
        self.categorical_encoder = None
        self.missing_value_imputer = None

    def fit(self, X, y=None):
        self.categorical_encoder = CategoricalEncoder(categorical_features=self.categorical_features)
        self.missing_value_imputer = MissingValueImputer(strategy=self.missing_value_strategy)
        self.categorical_encoder.fit(X)
        self.missing_value_imputer.fit(X)
        return self

    def transform(self, X):
        X = self.categorical_encoder.transform(X)
        X = self.missing_value_imputer.transform(X)
        return X

            

              
                Copy
              
            
          

Denne transformatoren bruker CategoricalEncoder og MissingValueImputer fra de forrige eksemplene for å utføre både one-hot-koding og imputering av manglende verdier i ett enkelt trinn.

Beste praksis for utvikling av egendefinerte transformatorer

Her er noen beste praksiser å følge når du utvikler egendefinerte transformatorer:

• Hold det enkelt: Hver transformator bør utføre én enkelt, veldefinert oppgave.
• Gjør den gjenbrukbar: Design transformatorene dine til å være så generiske som mulig, slik at de kan gjenbrukes i forskjellige pipelines.
• Håndter unntakstilfeller: Vurder hvordan transformatoren din vil håndtere unntakstilfeller, som manglende verdier, uteliggere og uventede datatyper.
• Skriv enhetstester: Skriv enhetstester for å sikre at transformatoren din fungerer korrekt.
• Dokumenter koden din: Dokumenter koden din tydelig slik at andre kan forstå hvordan de skal bruke transformatoren.

Eksempler fra den virkelige verden

La oss utforske noen flere eksempler på egendefinerte transformatorer fra den virkelige verden.

Funksjonsutvikling med datoer

Når du jobber med tidsseriedata, er det ofte nyttig å trekke ut funksjoner fra datoer, som ukedag, måned i året eller kvartal. Du kan lage en egendefinert transformator for å utføre denne oppgaven.

            class DateFeatureExtractor(BaseEstimator, TransformerMixin):
    def __init__(self, date_columns=None):
        self.date_columns = date_columns

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        for col in self.date_columns:
            X[col + '_dayofweek'] = X[col].dt.dayofweek
            X[col + '_month'] = X[col].dt.month
            X[col + '_quarter'] = X[col].dt.quarter
        return X

            

              
                Copy
              
            
          

Denne transformatoren trekker ut ukedag, måned og kvartal fra de spesifiserte datokolonnene.

Funksjonsutvikling med tekst

Når du jobber med tekstdata, er det ofte nyttig å utføre funksjonsutvikling ved hjelp av teknikker som TF-IDF eller ord-embeddings. Du kan lage egendefinerte transformatorer for å utføre disse oppgavene. Vurder for eksempel kundeanmeldelser på flere språk. Du kan trenge en egendefinert transformator som oversetter anmeldelsene til engelsk før du bruker TF-IDF-vektorisering.

Merk: Oversettelsestjenester krever ofte API-nøkler og kan medføre kostnader. Dette eksempelet fokuserer på strukturen til den egendefinerte transformatoren.

            # Merk: Dette eksempelet krever en oversettelsestjeneste (f.eks. Google Translate API) og API-nøkkel
# from googletrans import Translator # Eksempelbibliotek (installer med pip install googletrans==4.0.0-rc1)

class TextFeatureExtractor(BaseEstimator, TransformerMixin):
    def __init__(self, text_column, language='en'):
        self.text_column = text_column
        self.language = language
        # self.translator = Translator() # Instansier oversetter (krever oppsett)

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        # Eksempel: Oversett til engelsk (erstatt med faktisk oversettelseslogikk)
        # X[self.text_column + '_translated'] = X[self.text_column].apply(lambda text: self.translator.translate(text, dest=self.language).text)
        # Fiktiv oversettelse for demonstrasjonsformål
        X[self.text_column + '_translated'] = X[self.text_column].apply(lambda text: "Translated: " + text)

        # Bruk TF-IDF eller andre tekstvektoriseringsteknikker her
        return X

            

              
                Copy
              
            
          

Geospatial funksjonsutvikling

Når du jobber med geospatiale data, kan du lage egendefinerte transformatorer for å trekke ut funksjoner som avstand til nærmeste by, befolkningstetthet eller arealbrukstype. Vurder for eksempel å analysere eiendomspriser globalt. Du kan lage en egendefinert transformator som henter gjennomsnittlig inntektsnivå for et gitt sted ved hjelp av eksterne API-er basert på breddegrad og lengdegrad.

Integrering med eksisterende biblioteker

Egendefinerte transformatorer kan brukes til å pakke inn funksjonalitet fra andre Python-biblioteker i en scikit-learn pipeline. Dette lar deg utnytte kraften i andre biblioteker samtidig som du drar nytte av strukturen og organiseringen til en pipeline.

For eksempel kan du bruke en egendefinert transformator for å integrere et bibliotek for avviksdeteksjon, tidsserieprognoser eller bildebehandling i maskinlæringspipelinen din.

Konklusjon

Egendefinerte transformatorer er et kraftig verktøy for å bygge robuste og vedlikeholdbare maskinlæringspipelines i scikit-learn. Ved å kapsle inn din egendefinerte databehandlingslogikk i gjenbrukbare komponenter, kan du lage pipelines som er enklere å forstå, oppdatere og distribuere. Husk å følge beste praksis, skrive enhetstester og dokumentere koden din for å sikre at dine egendefinerte transformatorer er pålitelige og vedlikeholdbare. Etter hvert som du utvikler dine ferdigheter innen maskinlæring, vil mestring av utvikling av egendefinerte transformatorer bli uvurderlig for å takle komplekse og varierte problemer fra den virkelige verden over hele kloden. Fra håndtering av valutakonverteringer for internasjonal e-handel til behandling av sensordata fra IoT-enheter over hele verden, gir egendefinerte transformatorer deg muligheten til å skreddersy dine pipelines til de spesifikke behovene til dine data og applikasjoner.